package com.xzzz.irda.guardcat.client.alert;

import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import com.xzzz.common.base.util.okhttp.HttpUtil;
import com.xzzz.common.base.util.json.JsonUtil;
import com.xzzz.common.base.util.spring.SpringUtil;
import com.xzzz.irda.guardcat.client.GuardcatClientProperties;
import com.xzzz.irda.guardcat.core.constants.GuardcatConstant;
import com.xzzz.irda.guardcat.core.pojo.Alert;
import lombok.extern.slf4j.Slf4j;

/**
 * 发送警告
 *
 * @author xzzz
 */
@Slf4j
public class AlertClientSender {

    private static volatile GuardcatClientProperties guardcatClientProperties;
    private static final Object LOCK = new Object();

    /**
     * 获取客户端配置
     *
     * @return 客户端配置
     */
    private static GuardcatClientProperties getClientProperties() {
        if (guardcatClientProperties == null) {
            synchronized (LOCK) {
                if (guardcatClientProperties == null) {
                    guardcatClientProperties = SpringUtil.getBean(GuardcatClientProperties.class);
                }
            }
        }
        return guardcatClientProperties;
    }

    /**
     * 发送消息, 不发送通知, 任何环境都发送
     *
     * @param title   标题
     * @param content 内容
     */
    public static boolean send(String title, String content) {
        return send(title, content, false, false);
    }

    /**
     * 发送消息, 自定义是否发送通知, 任何环境都发送
     *
     * @param title   标题
     * @param content 内容
     */
    public static boolean send(String title, String content, boolean notification) {
        return send(title, content, notification, false);
    }

    /**
     * 发送消息
     *
     * @param title        标题
     * @param content      内容
     * @param notification 是否通知
     * @param onlyProd     为true则只有生产环境发送警告, 为false则任何环境都发送, 默认为true
     */
    public static boolean send(String title, String content, boolean notification, boolean onlyProd) {
        Alert alert = Alert.build(title, content, notification);
        return send(alert, onlyProd);
    }

    /**
     * 发送警告对象
     *
     * @param alert    警告对象
     * @param onlyProd 为true则只有生产环境发送警告, 为false则任何环境都发送, 默认为true
     * @return 是否发送成功
     */
    public static boolean send(Alert alert, boolean onlyProd) {
        if (notSend(alert, onlyProd)) {
            return false;
        }
        HttpUtil.post(getClientProperties().getServerUrl() + GuardcatConstant.API.ALERT_ADD, JsonUtil.toJson(alert));
        return true;
    }

    /**
     * 检查警告是否合法
     *
     * @param alert 警告对象
     */
    private static void check(Alert alert) {
        Assert.isFalse(StrUtil.isBlank(alert.getTitle()), "警告标题不得为空");
        Assert.isFalse(StrUtil.isBlank(alert.getContent()), "警告内容不的为空");
    }


    /**
     * 是否不发送
     *
     * @param alert    警告对象
     * @param onlyProd 是否只有生产环境发送警告
     * @return 返回 ture  则本次不发送;
     * 返回 false 则本次发送;
     */
    private static boolean notSend(Alert alert, boolean onlyProd) {
        if (onlyProd) {
            String profileAction = SpringUtil.getProfileAction();
            if (StrUtil.isBlank(profileAction)) {
                log.debug("警告只有生产环境发送, 本次不发送, title:{}, context:{}", alert.getTitle(), alert.getContent());
                return true;
            }
            if (!GuardcatConstant.ENV_PROD.equals(profileAction.toUpperCase())) {
                log.debug("警告只有生产环境发送, 本次不发送, title:{}, context:{}", alert.getTitle(), alert.getContent());
                return true;
            }
        }
        return false;
    }

}
